#pragma once
#include <iostream>
#include <vector>
#include <cstdint>
#include <string>
#include <cassert>
#include <cstring>
#include <ctime>
#include <typeinfo>
#include <functional>
#include <thread>
#include <mutex>
#include <memory>
#include <unordered_map>
#include <condition_variable>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>

#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL INF // 日志等级
#define TOSTRING(level) (                   \
    level == 0 ? "INF" : level == 1 ? "DBG" \
                     : level == 2   ? "ERR" \
                                    : "")
#define LOG(level, format, ...)                                                                                                               \
    do                                                                                                                                        \
    {                                                                                                                                         \
        if (level < LOG_LEVEL)                                                                                                                \
            break;                                                                                                                            \
        time_t t = time(nullptr);                                                                                                             \
        struct tm *ltm = localtime(&t);                                                                                                       \
        char tmp[32] = {0};                                                                                                                   \
        strftime(tmp, sizeof(tmp) - 1, "%Y:%m:%d %H:%M:%S", ltm);                                                                             \
        fprintf(stdout, "[%p][%s][%s][%s:%d] " format "\n", (void *)pthread_self(), TOSTRING(level), tmp, __FILE__, __LINE__, ##__VA_ARGS__); \
    } while (0)

#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)

#define BUFFER_DEFAULT_SIZE 1024 // 缓冲区默认大小
class Buffer
{
private:
    std::vector<char> _buffer;
    uint64_t _reader_idx; // 读偏移
    uint64_t _writer_idx; // 写偏移

public:
    Buffer() : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    // 获取起始地址
    char *Begin() { return &(*_buffer.begin()); } //_buffer.begin()是一个迭代器，解引用拿到第一个char，再取地址
    // 获取当前读起始地址
    char *ReadPosition() { return Begin() + _reader_idx; }
    // 获取当前写起始地址
    char *WritePosition() { return Begin() + _writer_idx; }
    // 获取缓冲区末尾空闲空间大小
    uint64_t TailIdleSize() { return _buffer.size() - _writer_idx; }
    // 获取缓冲区起始空间大小
    uint64_t HeadIdleSize() { return _reader_idx; }
    // 获取可读数据大小
    uint64_t ReadAbleSize() { return _writer_idx - _reader_idx; }
    // 将读偏移向后移动
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)
            return;
        assert(len <= ReadAbleSize());
        _reader_idx += len;
    }
    // 将写偏移向后移动
    void MoveWriteOffset(uint64_t len)
    {
        if (len == 0)
            return;

        assert(len <= TailIdleSize());
        _writer_idx += len;
    }
    // 确保可写空间足够 （整体空闲空间吼了就移动数据，否则就扩容）
    void EnsureWriteSpace(uint64_t len)
    {
        if (TailIdleSize() >= len)
        {
            return;
        }
        else if (len <= TailIdleSize() + HeadIdleSize())
        {
            uint64_t rsz = ReadAbleSize();
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin());

            // 更新读写偏移
            _reader_idx = 0;
            _writer_idx = rsz;
        }
        else
        {
            _buffer.resize(_writer_idx + len);
        }
    }
    // 写入数据
    void Write(const void *data, uint64_t len)
    {
        // 1.保证有足够空间 2.拷贝数据进去
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        const char *d = (const char *)data;
        std::copy(d, d + len, WritePosition());
    }
    void WriteAndPush(const void *data, uint64_t len)
    {
        Write(data, len);
        MoveWriteOffset(len);
    }
    void WriteString(const std::string &data)
    {
        return Write(data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string &data)
    {
        WriteString(data);
        MoveWriteOffset(data.size());
    }
    void WriteBuffer(Buffer &data)
    {
        Write(data.ReadPosition(), data.ReadAbleSize());
    }
    void WriteBufferAndPush(Buffer &data)
    {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadAbleSize());
    }
    // 读取数据
    void Read(void *buf, uint64_t len)
    {
        // 要求要获取的数据大小必须小于可读数据大小
        assert(len <= ReadAbleSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
    }
    void ReadAndPop(void *buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }
    std::string ReadAsString(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str;
        str.resize(len);
        // str.c_str()会返回一个const char*不能更改
        Read(&str[0], len);
        return str;
    }
    std::string ReadAsStringAndPop(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }
    // 获取一行数据
    std::string GetLine()
    {
        char *pos = FindCRLF();
        if (pos == nullptr)
        {
            return "";
        }
        //+1是为了把换行字符也取出来
        return ReadAsString(pos - ReadPosition() + 1);
    }

    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }

    // 寻找回车换行
    char *FindCRLF()
    {
        char *res = (char *)memchr(ReadPosition(), '\n', ReadAbleSize());
        return res;
    }
    // 清空缓冲区
    void Clear()
    {
        _reader_idx = 0;
        _writer_idx = 0;
    }
};

class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info &type() = 0;
        virtual holder *clone() = 0;
    };

    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T &val) : _val(val) {}                     // 构造
        virtual const std::type_info &type() { return typeid(T); }   // 获取子类对象保存的数据类型
        virtual holder *clone() { return new placeholder<T>(_val); } // 针对当前对象自身，克隆一个新的子类对象

    public:
        T _val;
    };

    holder *_content; // 父类指针，接收子类对象，子类对象可以是任意类型

public:
    Any() : _content(nullptr){}; // 默认构造
    ~Any() { delete _content; }  // 析构

    template <class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {}
    // （other._content ? other._content->clone() : nullptr）   如果other._content不为空 则克隆一个子类对象 否则返回nullptr
    Any(const Any &other) : _content(other._content ? other._content->clone() : nullptr) {}

    template <class T>
    Any &operator=(const T &val)
    {
        // 现代写法的赋值拷贝
        Any(val).swap(*this);
        return *this;
    }

    Any &operator=(const Any &other)
    {
        // 现代写法的赋值拷贝
        Any(other).swap(*this);
        return *this;
    }

    // 获取子类对象保存的数据的地址
    template <class T>
    T *get()
    {
        // 想要获取的类型必须和子类对象保存的数据的类型一样
        assert(typeid(T) == _content->type());
        return &((placeholder<T> *)_content)->_val;
    }

    // 用于赋值拷贝
    Any &swap(Any &other)
    {
        std::swap(other._content, _content);
        return *this;
    }
};

#define MAX_LINTEN 1024
class Socket
{
private:
    int _sockfd;

public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() { Close(); }
    // 获取_sockfd
    int Fd() { return _sockfd; }

public:
    // 创建套接字
    bool Create()
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            ERR_LOG("CREAT SOCKET FAILED!!");
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());

        int ret = bind(_sockfd, (const struct sockaddr *)&addr, sizeof(addr));
        if (ret < 0)
        {
            ERR_LOG("BIND ADDRESS FAILED!");
            return false;
        }
        return true;
    }
    // 开始监听
    bool Listen(int blocklog = MAX_LINTEN)
    {
        int ret = listen(_sockfd, blocklog);
        if (ret < 0)
        {
            ERR_LOG("SOCKET LISTEN FAILED!!");
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string &serverip, uint16_t serverport)
    {
        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(serverport);
        addr.sin_addr.s_addr = inet_addr(serverip.c_str());

        int ret = connect(_sockfd, (struct sockaddr *)&addr, sizeof(addr));
        if (ret < 0)
        {
            ERR_LOG("Connect SERVER FAILED!");
            return false;
        }
        return true;
    }
    // 获取新连接
    int Accept()
    {
        int newfd = accept(_sockfd, nullptr, nullptr);
        if (newfd < 0)
        {
            ERR_LOG("SOCKET ACCEPT FAILED!!");
            return -1;
        }
        return newfd;
    }
    // 接收数据
    ssize_t Recv(void *buf, size_t len, int flag = 0)
    {
        ssize_t ret = recv(_sockfd, buf, len, flag);
        if (ret <= 0)
        {
            // EAGAIN 当前socket的接收缓冲区没有数据了，在非阻塞才会有这个情况
            // EINTR 表示当前socket的阻塞等待 被信号打断
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0; // 表示这次没有收到数据
            }
            // recv出错误了 ，注意，我们这里没有收到数据也是出错返回
            ERR_LOG("SOCKET RECV FAILED!!");
            return -1;
        }
        return ret; // 实际接收的字节数
    }
    // 发送数据
    ssize_t Send(const void *buf, size_t len, int flag = 0)
    {
        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret < 0)
        {
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0; // 表示这次没有发送数据
            }
            // 当ret<0代表recv出错了
            ERR_LOG("SOCKET SEND FAILED!!");
            return -1;
        }
        return ret; // 实际发送的字节数
    }
    ssize_t NonBlockRecv(void *buf, size_t len)
    {
        return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT代表当前接收为非阻塞
    }
    ssize_t NonBlockSend(void *buf, size_t len)
    {
        return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT代表当前发送为非阻塞
    }
    // 关闭套接字
    void Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }
    // 创建一个服务端连接
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool flag = false)
    {

        if (Create() == false)
            return false;
        if (flag)
            NonBlock();
        if (Bind(ip, port) == false)
            return false;
        if (Listen() == false)
            return false;
        ReuseAddress();

        return true;
    }
    // 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string &ip)
    {
        if (Create() == false)
            return false;
        if (Connect(ip, port) == false)
            return false;
        return true;
    }
    // 开启地址端口复用
    void ReuseAddress()
    {
        int val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int));
        val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(int));
    }
    // 设置为非阻塞
    void NonBlock()
    {
        int fl = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, fl | O_NONBLOCK);
    }
};

class Poller;
class EventLoop;
class Channel
{
private:
    int _fd;
    EventLoop *_loop;  // 当需要移除监控的时候，要在EventLoop中调用Poller的RemoveEvent();
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    EventCallback _read_callback;  // 可读事件被触发的回调函数
    EventCallback _write_callback; // 可写事件被触发的回调函数
    EventCallback _error_callback; // 错误事件被触发的回调函数
    EventCallback _close_callback; // 连接断开事件被触发的回调函数
    EventCallback _event_callback; // 任意事件被触发的回调函数,本质就是刷新活跃度
public:
    Channel(EventLoop *loop, int fd) : _loop(loop), _fd(fd), _events(0), _revents(0) {}
    int Fd() { return _fd; }
    // 获取当前监控的事件
    uint32_t Events() { return _events; }
    // 设置当前连接触发的事件
    void SetREvents(uint32_t events) { _revents = events; }

    // 设置事件处理回调函数
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }

    // 当前是否监控了可读
    bool ReadAble() { return (_events & EPOLLIN); }

    // 当前是否监控了可写
    bool WriteAble() { return (_events & EPOLLOUT); }

    // 启动读事件监控
    void EnableRead()
    {
        _events |= EPOLLIN;
        // 需要将_events设置进内核的红黑树中（Poller模块）
        Update();
    }

    // 启动写事件监控
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }

    // 关闭读事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update();
    }

    // 关闭写事件监控
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }

    // 关闭所有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }

    // 移除监控（从epoll的rb_tree中）
    void Remove();
    void Update();

    // 事件处理，一旦触发了事件，就调用这个函数（需要在EventLoop中调用），自己触发了什么事件如何处理自己决定
    void HandleEvent()
    {
        // EPOLLRDHUP表示对端关闭了连接    EPOLLPRI表示有紧急数据可读
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            /*不管任何事件，都调用的回调函数 刷新活跃度*/
            if (_event_callback)
                _event_callback();

            if (_read_callback)
                _read_callback();
        }

        if (_revents & EPOLLOUT)
        {
            /*不管任何事件，都调用的回调函数 刷新活跃度*/
            if (_event_callback)
                _event_callback();

            if (_write_callback)
                _write_callback();
        }
        else if (_revents & EPOLLERR)
        {
            /*不管任何事件，都调用的回调函数*/
            if (_event_callback)
                _event_callback();

            if (_error_callback)
                _error_callback();
        }
        else if (_revents & EPOLLHUP)
        {
            /*不管任何事件，都调用的回调函数*/
            if (_event_callback)
                _event_callback();

            if (_close_callback)
                _close_callback();
        }
    }
};

#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];     // 存储已经就绪的事件
    std::unordered_map<int, Channel *> _channels; // (fd,channel) 用来管理Channel,是否已经添加了事件监控,事件是否就绪
private:
    // 对epoll的直接操作
    void Update(Channel *channel, int op)
    {
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        // 要监控的fd和对应关心的事件设置进红黑树
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
        {
            ERR_LOG("EPOLLCTL FAILED!");
        }
        return;
    }
    // 判断一个Channel是否已经添加了事件监控
    bool HasChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
        {
            return false;
        }

        return true;
    }

public:
    Poller()
    {
        // 创建epoll模型
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if (_epfd < 0)
        {
            ERR_LOG("EPOLL CREATE FAILED!!");
            abort(); // 退出程序
        }
    }

    // 添加或修改事件监控
    void UpdateEvent(Channel *channel)
    {
        /*EPOLL_CTL_ADD: 将文件描述符添加到 epoll 监控集合中。如果文件描述符已经在集合中，将会返回一个错误。
        EPOLL_CTL_MOD: 修改已经在 epoll 监控集合中的文件描述符的事件监听属性。该操作允许修改文件描述符的监听事件，例如修改关注的事件类型、修改关注的条件等。*/
        bool ret = HasChannel(channel);
        // 如果不在则添加
        if (ret == false)
        {
            _channels.insert(std::make_pair(channel->Fd(), channel));
            Update(channel, EPOLL_CTL_ADD);
        }

        Update(channel, EPOLL_CTL_MOD);
    }

    // 移除监控
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
        {
            _channels.erase(it);
        }

        Update(channel, EPOLL_CTL_DEL);
    }

    // 开始监控(从内核队列获取就绪的事件)，并返回活跃连接给上层
    void poll(std::vector<Channel *> *active)
    {
        //-1是阻塞等待
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
        if (nfds < 0)
        {
            // 被信号中断了 不是致命错误，return返回就行
            if (errno == EINTR)
            {
                return;
            }

            // epoll_wait出错了，需要终止程序
            ERR_LOG("EPOLL WAIT ERROR:%s", strerror(errno));
            abort(); // 退出程序
        }
        for (int i = 0; i < nfds; i++)
        {
            auto it = _channels.find(_evs[i].data.fd);
            // 如果就绪的fd不在我们管理的unordered_map中，就断言
            assert(it != _channels.end());
            // 给channel设置就绪的事件
            it->second->SetREvents(_evs[i].events);
            // 将channel插入到vector中,返回给上层用户
            active->push_back(it->second);
        }
        return;
    }
};

using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimerTask
{
private:
    uint64_t _id;         // 定时器任务对象id
    uint32_t _timeout;    // 定时任务的超时时间
    bool _canceled;       // false-表⽰没有被取消， true-表⽰被取消
    TaskFunc _task_cb;    // 定时器对象要执行的定时任务
    ReleaseFunc _release; // 用于删除TimerWheel中保存的定时器对象信息
public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb)
        : _id(id), _timeout(delay), _canceled(false), _task_cb(cb) {}

    ~TimerTask()
    {
        // 判断任务是否取消
        if (_canceled == false)
            _task_cb();

        _release();
    }

    // 设置release回调
    void SetRelease(const ReleaseFunc &cb) { _release = cb; }
    uint32_t DelayTime() { return _timeout; }
    // 取消定时任务
    void Cancel() { _canceled = true; }
};

class EventLoop;
using PtrTask = std::shared_ptr<TimerTask>;
using WeakTask = std::weak_ptr<TimerTask>;
class TimerWheel
{
private:
    int _tick;                                      // 滴答指针，走到那里就释放那里，相当于当前执行哪里的任务
    int _capacity;                                  // 时间轮的最大数量  相当于最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;       // 时间轮 里面存放的是shared_ptr管理的定时器任务
    std::unordered_map<uint64_t, WeakTask> _timers; // （taskid,weak_ptr<task>） 用于管理时间轮中的定时器任务，使用的是Weak_ptr

    EventLoop *_loop;                        // 为了初始化_timer_channel
    int _timefd;                             // 定时器描述符--可读事件回调就是读取计数器，执⾏定时任务
    std::unique_ptr<Channel> _timer_channel; // 为定时器描述符创建的channel对象

private:
    // 移除_timers中的定时器任务信息
    void RemoveTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end())
        {
            _timers.erase(it);
        }
    }

    static int CreateTimerFd()
    {
        // 创建一个定时器描述符，他的返回值是一个文件描述符，MONOTONIC代表相对时间,0代表阻塞属性
        int timefd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timefd < 0)
        {
            ERR_LOG("TIMERFD CREATE FAILED");
            abort();
        }
        struct itimerspec itime;
        // 设置第一次超时时间为1秒
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0; // 单位微妙

        // 设置第一次之后的超时时间间隔
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0;

        // 启动定时器
        //  成功时返回0,失败返回-1，设置errno码
        int n = timerfd_settime(timefd, 0, &itime, nullptr); // 启动定时器
        if (n < 0)
        {
            ERR_LOG("TIMERFD SETTIME FAILED");
            abort();
        }

        return timefd;
    }

    // 对_timefd进行读取
    uint64_t ReadTimerFd()
    {
        uint64_t times;
        int n = read(_timefd, &times, 8);
        if (n < 0)
        {
            ERR_LOG("READ TIMEFD FAILED");
            abort();
        }

        return times;
    }

    // timefd的可读事件回调，当timefd可读事件就绪，就执行这个函数，让时间轮走起来
    void OnTime()
    {
        // 根据实际超时的次数，执⾏对应的超时任务
        int times = ReadTimerFd();
        for (int i = 0; i < times; i++)
        {
            RunTimerTask();
        }
    }

    // 添加定时器任务
    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb)
    {
        PtrTask pt(new TimerTask(id, delay, cb));
        // 绑定定时器任务pt的release回调函数
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
        // 拷贝构造了一个Weak_ptr的pt对象插入_timers中
        _timers[id] = WeakTask(pt);
    }

    // 延迟or刷新定时任务 延迟时间为定时器任务中设置的_timeout时间
    void TimerRefreshInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return; // 没找着任务，么办法刷新
        }

        PtrTask pt = it->second.lock(); // lock返回一个weak_ptr管理对象的一个Shared_ptr指针
        int delay = pt->DelayTime();
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
        // for debug
        // std::cout << "延迟成功" << std::endl;
    }

    // 取消定时任务
    void TimerCancelInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            // 没找到定时任务，没法取消
            return;
        }

        PtrTask pt = it->second.lock();
        // lock失败会返回空指针
        if (pt)
            pt->Cancel();
    }

    // 这个函数每秒钟被执行一次，滴答指针就会向后移动一位
    void RunTimerTask()
    {
        //_tick向后移动一位
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear(); // 清空指定位置的数组，就会把数组中的shared_ptr释放掉
    }

public:
    TimerWheel(EventLoop *loop) : _capacity(60), _tick(0), _wheel(_capacity),
                                  _loop(loop), _timefd(CreateTimerFd()), _timer_channel(new Channel(_loop, _timefd))
    {
        // 设置_timefd可读事件回调
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));

        // 启动读事件监控
        _timer_channel->EnableRead();
    }

    /*定时器中有个_timers成员，定时器信息的操作有可能在多线程中进⾏，因此需要考虑线程安全问题*/
    /*如果不想加锁，那就把对定期的所有操作，都放到⼀个线程中进⾏*/
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
    void TimerRefresh(uint64_t id);
    void TimerCancel(uint64_t id);

    /*这个函数存在线程安全问题--这个函数实际上不能被外界使⽤者调⽤，只能在模块内，在对应的EventLoop线程内执⾏*/
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return false;
        }
        return true;
    }
};

class EventLoop
{
private:
    std::thread::id _thread_id;            // 线程ID
    int _event_fd;                         // efd事件通知
    std::unique_ptr<Channel> _efd_channel; // 监控efd创建的channel
    Poller _poller;
    using Functor = std::function<void()>;
    std::vector<Functor> _tasks; // 任务队列
    std::mutex _mutex;           // 保证任务队列线程安全的锁

    TimerWheel _timer_wheel; // 定时器模块

private:
    static int CreateEventFd()
    {
        // EFD_CLOEXEC表示不会被子进程所继承（文件描述符不会被继承），EFD_NONBLOCK表示非阻塞
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            ERR_LOG("CREATE EVENTFD FAILED!!");
            abort(); // 终止进程
        }
        return efd;
    }

    // 执行任务池中的所有任务
    void RunAllTask()
    {
        // 创建一个临时的任务队列
        std::vector<Functor> functor;
        // 确定生命周期，方便释放锁
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            // 把任务队列中的任务放到自己的临时队列（线程的独立栈，其他线程看不到）中，这样就不会出现线程安全的问题???
            _tasks.swap(functor);
        }

        for (auto &f : functor)
        {
            f();
        }
        return;
    }

    // 对_event_fd进行读取
    void ReadEventFd()
    {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret <= 0)
        {
            // EINTR -- 被信号打断； EAGAIN -- 表⽰⽆数据可读
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            ERR_LOG("READ EVENTFD FAILED!");
            abort();
        }
        return;
    }
    // 对_event_fd进行写入，我们的poller监控了efd,这样就唤醒了poller
    void WeakUpEventFd()
    {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            // EINTR -- 被信号打断
            if (errno == EINTR)
            {
                return;
            }
            ERR_LOG("READ EVENTFD FAILED!");
            abort();
        }
        return;
    }

public:
    EventLoop() : _thread_id(std::this_thread::get_id()),
                  _event_fd(CreateEventFd()),
                  _efd_channel(new Channel(this, _event_fd)),
                  _timer_wheel(this)
    {
        // 给eventfd添加可读事件回调，读取eventfd事件通知次数
        _efd_channel->SetReadCallback(std::bind(&EventLoop::ReadEventFd, this));

        // 启动eventfd的读事件监控
        _efd_channel->EnableRead();
    }

    // 事件监控-》就绪事件处理-》执行任务
    void Start()
    {
        while (1)
        {
            // 1.事件监控
            std::vector<Channel *> active;
            _poller.poll(&active);
            // 2.事件处理
            for (auto &channel : active)
            {
                channel->HandleEvent();
            }
            // 3.执行任务
            RunAllTask();
        }
    }

    // 判断当前线程是否是EventLoop对应的线程
    bool IsInLoop()
    {
        return (_thread_id == std::this_thread::get_id());
    }

    void AssertInLoop()
    {
        assert(_thread_id == std::this_thread::get_id());
    }

    // 判断当前要执行的任务是否处于当前线程中，如果是则执行，不是则压入队列
    void RunInLoop(const Functor &cb)
    {
        if (IsInLoop())
        {
            return cb();
        }

        return QueueInLoop(cb);
    }

    // 将操作压入任务池
    void QueueInLoop(const Functor &cb)
    {
        // 限制生命周期，释放锁
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }

        // 唤醒有可能因为没有事件就绪，而导致的epoll阻塞 (epoll_wait阻塞) Start函数中需要先对就绪任务处理后才执行任务
        // 其实就是给eventfd写入一个数据,eventfd就会触发可读事件
        WeakUpEventFd();
    }

    // 添加/修改描述符的事件监控
    void UpdateEvent(Channel *channel)
    {
        _poller.UpdateEvent(channel);
    }

    // 移除描述符的监控
    void RemoveEvent(Channel *channel)
    {
        _poller.RemoveEvent(channel);
    }

    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) { _timer_wheel.TimerAdd(id, delay, cb); }
    void TimerRefresh(uint64_t id) { _timer_wheel.TimerRefresh(id); }
    void TimerCancel(uint64_t id) { _timer_wheel.TimerCancel(id); }
    bool HasTimer(uint64_t id) { return _timer_wheel.HasTimer(id); }
};

//创建一个线程，同时为创建eventloop绑定该线程
class LoopThread
{
private:
    /*用于实现_loop获取的同步关系，避免线程创建了，但是_loop还没有实例化之前去获取_loop*/
    std::mutex _mutex;             // 互斥锁
    std::condition_variable _cond; // 条件变量

    EventLoop *_loop;              // EventLoop指针变量，这个对象需要在线程内实例化，因为EventLoop的构造函数就是是用std::this_thread::get_id()
    std::thread _thread;           // EventLoop对应的线程

private:
    // 实例化EventLoop对象，唤醒_cond上有可能阻塞的线程，并且开始运行EventLoop模块的功能
    void ThreadEntry()
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;

            _cond.notify_all();
        }

        //启动监控
        _loop->Start();
    }

public:
    // 创建线程，设定线程入口函数
    LoopThread() : _loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}
    // 返回当前线程关联的EventLoop指针
    EventLoop *GetLoop()
    {
        EventLoop *loop = nullptr;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            // 等待在条件变量，知道_loop不为nullptr才解除阻塞
            _cond.wait(lock, [&]()
                       { return _loop != nullptr; });

            loop = _loop;
        }
        return loop;
    }
};

class LoopThreadPool
{
private:
    int _thread_count;                  // 从属线程数量
    int _next_idx;                      // 下一个分配线程的index
    EventLoop *_base_loop;              // 主线程绑定的Eventloop 如果从属线程数量为0，也就是单线程Reactor模型,_base_loop既需要处理新连接，也需要处理事件
    std::vector<LoopThread *> _threads; // 管理所有的从属线程
    std::vector<EventLoop *> _loops;    // 管理所有的从属线程绑定的EventLoop
public:
    LoopThreadPool(EventLoop *baseloop) : _thread_count(0), _next_idx(0), _base_loop(baseloop) {}

    // 设置要创建的从属线程的数量
    void SetThreadCount(int count)
    {
        _thread_count = count;
    }

    // 创建从属线程并启动
    void CreatAndStart()
    {
        _threads.resize(_thread_count);
        _loops.resize(_thread_count);

        for (int i = 0; i < _thread_count; i++)
        {
            _threads[i] = new LoopThread(); // LoopThread的构造函数会启动EventLoop
            _loops[i] = _threads[i]->GetLoop();
        }
        return;
    }

    // 分配一个EventLoop，采用RR轮转的方式
    EventLoop *NextLoop()
    {
        if (_thread_count == 0)
        {
            return _base_loop;
        }

        _next_idx = (_next_idx + 1) % _thread_count;
        return _loops[_next_idx];
    }
};

class Connection;
// DISCONNECTED -- 连接关闭状态； CONNECTING -- 连接建⽴成功-待处理状态
// CONNECTED -- 连接建⽴完成，各种设置已完成，可以通信的状态； DISCONNECTING -- 待关闭状态
enum ConnStatu
{
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    DISCONNECTING
};
using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection>
{
private:
    uint64_t _conn_id;             // 连接的唯一ID,便于连接的管理和查找
    //_timer_id                    //定时任务Id,标识定时任务的唯一性，我们这里用_conn_id代替了
    int _sockfd;                   // 文件描述符
    bool _enable_inactive_release; // 是否启动非活跃销毁的标志，默认为false
    EventLoop *_loop;              // 连接所关联的一个EventLoop
    ConnStatu _statu;              // 连接状态
    Socket _socket;                // 套接字操作管理
    Channel _channel;              // 连接的事件管理
    Buffer _in_buffer;             // 输入缓冲区 ---存放从socket中读取的数据
    Buffer _out_buffer;            // 输出缓冲区 ---存放要发送给对端的数据
    Any _context;                  // 请求的接收处理上下文
    
    /*这四个回调函数，是让服务器模块来设置的（其实服务器模块的处理回调也是组件使⽤者设置的）*/
    /*所以说，这⼏个回调都是组件使⽤者使⽤的*/
    // 这四个回调函数是在连接的不同状态调用的，要清楚他和channel的回调函数的区别
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    /*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，⼀旦某个连接要关闭*/
    /*就应该从管理的地⽅移除掉⾃⼰的信息*/
    ClosedCallback _server_closed_callback;

private:
    /*五个channel的事件回调函数*/
    // 描述符可读事件触发后调用的函数，接收socket数据放到接收缓冲区，然后调用_message_callback进行业务处理
    void HandleRead()
    {
        // 1.接收socket的数据,放到缓冲区
        char buf[66636];
        ssize_t ret = _socket.NonBlockRecv(buf, 65535);
        if (ret < 0) // recv出错了或者没有读到数据都会进入这个if
        {
            // 出错了,不能直接关闭
            return ShutDown();
        }
        // 将数据放入输入缓冲区
        _in_buffer.WriteAndPush(buf, ret);
        // 2.调用_message_callback进行业务处理
        if (_in_buffer.ReadAbleSize() > 0)
        {
            // shared_from_this()总当前对象自身获取自身的shared_ptr对象
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }

    /*描述符可写事件触发后调用的函数,将发送缓冲区的数据进行发送*/
    void HandleWrite()
    {
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
        if (ret < 0)
        {
            // 发送错误就该关闭连接了,关闭连接前先看是否有数据待处理
            if (_in_buffer.ReadAbleSize() > 0)
            {
                _message_callback(shared_from_this(), &_in_buffer);
            }
            return Release(); // 这时候就是实际的关闭释放连接了

            /*为啥读事件错误是执行ShutDownInLoop，而写事件错误就执行Release呢？*/
            // 我们是先启动的读事件监控，而写事件监控只有两个地方会启动：1.shutdown（数据已经读完了） 2.Send(我们给对端发送数据) 所以必定读事件先执行。
        }
        _out_buffer.MoveReadOffset(ret); // 将读偏移向后移动，因为我们已经发送了ret字节的数据
        if (_out_buffer.ReadAbleSize() == 0)
        {
            _channel.DisableWrite(); // 没有数据待发送了，关闭写监控，不然会一直触发写事件就绪
            // 如果当前是连接待关闭状态，则直接释放连接
            if (_statu == DISCONNECTING)
            {
                return Release();
            }
        }
        return;
    }

    /*描述符触发关闭事件*/
    void HandleClose()
    {
        // 关闭连接之前，先查看是否有数据待处理
        if (_in_buffer.ReadAbleSize() > 0)
        {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return Release();
    }

    /*描述符触发出错事件*/
    void HandleError()
    {
        return HandleClose();
    }

    /*描述符触发任意事件,1.刷新连接的活跃度--延迟定时销毁任务；2.调用组建使用者设置的任意时间回调*/
    void HandleEvent()
    {
        if (_enable_inactive_release == true)
        {
            _loop->TimerRefresh(_conn_id);
        }
        // 如果组件使用者设置了任意事件回调
        if (_event_callback)
        {
            _event_callback(shared_from_this());
        }
    }

    // 连接获取之后，所处的状态下要进行各种设置（启动读监控，调用回调函数）
    void EstablishedInLoop()
    {
        // 1.修改连接状态
        assert(_statu == CONNECTING); // 当前状态必须是半连接状态
        _statu = CONNECTED;
        // 2.启动读事件监控
        _channel.EnableRead();
        // 3.调用回调函数
        if (_connected_callback)
            _connected_callback(shared_from_this());
    }

    /*这个接口才是实际的释放接口*/
    void ReleaseInLoop()
    {
        // 1.修改连接状态，将其设置为DISCONNECTED
        _statu = DISCONNECTED;
        // 2.移除连接的事件监控
        _channel.Remove();
        // 3.关闭描述符
        _socket.Close();
        // 4.如果当前定时器队列中还有定时销毁任务，则取消任务
        if (_loop->HasTimer(_conn_id))
            CancelInactiveReleaseInLoop();
        // 5.调用关闭回调函数 避免先移除服务器管理的连接信息导致Connection被释放，再去处理会出错，因此先调⽤⽤⼾的回调函数
        if (_closed_callback)
            _closed_callback(shared_from_this());
        if (_server_closed_callback)
            _server_closed_callback(shared_from_this());
    }

    /*这个接口并不是实际的发送接口，而只是把数据放到了发送缓冲区，启动了写事件监控*/
    void SendInLoop(Buffer &buf) //接收了一个右值，减少拷贝
    {
        if (_statu == DISCONNECTED)
            return;
        _out_buffer.WriteBufferAndPush(buf);
        if (_channel.WriteAble() == false)
        {
            _channel.EnableWrite();
        }
    }

    /*这个关闭操作并非实际的连接释放操作，需要判断还有没有数据待处理，待发送*/
    void ShutDownInLoop()
    {
        _statu = DISCONNECTING; // 连接状态设置为半关闭
        if (_in_buffer.ReadAbleSize() > 0)
        {
            if (_message_callback)
            {
                _message_callback(shared_from_this(), &_in_buffer);
            }
        }
        // 要么就是写入数据的时候出错关闭(Release)，要么就是没有待发送的数据，直接关闭(Release)
        if (_out_buffer.ReadAbleSize() > 0)
        {
            if (_channel.WriteAble() == false)
            {
                _channel.EnableWrite();
            }
        }
        if (_out_buffer.ReadAbleSize() == 0)
        {
            Release();
        }
    }

    /*启动非活跃连接超时释放*/
    void EnableInactiveReleaseInLoop(int sec)
    {
        // 1.将标志位_enable_inactive_release置为true
        _enable_inactive_release = true;
        // 2.如果当前定时销毁任务已经存在，那就刷新延迟一下
        if (_loop->HasTimer(_conn_id))
        {
            return _loop->TimerRefresh(_conn_id);
        }
        // 不存在，则新增
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }

    /*取消非活跃超时连接*/
    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
        {
            _loop->TimerCancel(_conn_id);
        }
    }

    void UpgradeInLoop(const Any &context,
                       const ConnectedCallback &conn,
                       const MessageCallback &msg,
                       const ClosedCallback &closed,
                       const AnyEventCallback &event)
    {
        _context = context;
        _connected_callback = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }

public:
    Connection(EventLoop *loop, uint64_t conn_id, int sockfd)
        : _conn_id(conn_id), _sockfd(sockfd), _enable_inactive_release(false), _loop(loop),
          _statu(CONNECTING), _socket(_sockfd), _channel(loop, _sockfd)
    {
        // 不能在构造函数启动读监控，因为启动了读监控可能立即就有事件触发，我们还没有设置定时任务，这时就会出错
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
    }

    ~Connection()
    {
        // 析构函数就打印一个日志,查看是否正确释放对象
        DBG_LOG("RELEASE CONNECTION:%p", this);
    }

    // 获取管理的文件描述符
    int Fd() { return _sockfd; }
    // 获取连接ID
    int Id() { return _conn_id; }
    // 是否处于CONNECTED状态
    bool Connected() { return (_statu == CONNECTED); }
    // 设置上下文--连接建立完成时进行调用
    void SetContext(const Any &context) { _context = context; }
    // 获取上下文，返回的是指针
    Any *GetContext() { return &_context; }

    /*设置回调*/
    void SetConnectedCalllback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCalllback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCalllback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCalllback(const AnyEventCallback &cb) { _event_callback = cb; }
    void SetSrvClosedCalllback(const ClosedCallback &cb) { _server_closed_callback = cb; }

    // 连接建立就绪后进行channel回调设置，启动读监控，调用_connected_callback
    void Established()
    {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }

    // 发送数据，将数据发送到缓冲区，启动写事件监控
    void Send(const char *data, size_t len)
    {
        // 外界传入的data,可能是个临时空间，我们现在只是把操作压入了任务池，又可能并没有执行
        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf))); //SendInLoop的形参用引用接收，减少拷贝
    }

    // 提供给组件使用者的关闭接口---并不实际关闭，需要判断是否有数据待处理
    void ShutDown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutDownInLoop, this));
    }

    // QueueInLoop将ReleaseInLoop压入任务队列
    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }

    // 启动非活跃销毁，并定义多长时间无通信就是非活跃，添加定时任务
    void EnableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }

    // 取消非活跃销毁
    void CancelInactiveRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }

    // 切换协议---重置上下⽂以及阶段性回调处理函数 -- ⽽是这个接⼝必须在EventLoop线程中⽴即执⾏
    // 防备新的事件触发后，处理的时候，切换任务还没有被执⾏--会导致数据使⽤原协议处理了。
    void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
                 const ClosedCallback &closed, const AnyEventCallback &event)
    {
        // 当前函数必须在对应的线程中执行
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    }
};

class Acceptor
{
private:
    Socket _socket;   // 创建套接监听字
    EventLoop *_loop; // 套接监听字的事件监控
    Channel _channel; // 套件监听字的事件管理

    using AcceptCallback = std::function<void(int)>; // int为newfd
    // 获取新连接后要调用的回调函数
    AcceptCallback _accept_callback;

private:
    // 监听套接字的读事件回调处理函数,获取新连接，调⽤_accept_callback函数进⾏新连接处理
    void HandleRead()
    {
        int newfd = _socket.Accept();
        if (newfd < 0)
        {
            return;
        }

        if (_accept_callback)
            _accept_callback(newfd);
    }

    int CreateServer(uint16_t port)
    {
        bool ret = _socket.CreateServer(port);
        assert(ret == true);
        return _socket.Fd();
    }

public:
    /*不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动*/
    /*否则有可能造成启动监控后，⽴即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏*/
    Acceptor(EventLoop *loop, uint16_t port) : _socket(CreateServer(port)), _loop(loop), _channel(_loop, _socket.Fd())
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
    }

    void SetAcceptCallBack(const AcceptCallback &cb) { _accept_callback = cb; };
    // 启动读事件监控
    void Listen() { _channel.EnableRead(); }
};

class TcpServer
{
private:
    uint64_t _next_id; // 一个自增长的Conn的ID,也用做与定时任务的Id
    uint16_t _port;    // 服务器监听的端口号

    /*这两个成员变量是针对从属线程的conn设置的*/
    int _timeout;                  // 定时任务的超时时间
    bool _enable_inactive_release; // 是否启动定时销毁任务

    EventLoop _baseloop;                                // 这是主线程的EventLoop对象，负责监听事件的处理
    Acceptor _acceptor;                                 // 这是监听套接字的管理对象
    LoopThreadPool _pool;                               // 这是从属EventLoop线程池
    std::unordered_map<uint64_t, PtrConnection> _conns; // 管理所有的conn连接

    /*新连接conn对象要设置的回调函数*/
    using Functor = std::function<void()>;
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;

private:
    // 添加一个定时任务
    void TimerAddInLoop(const Functor &cb, int delay)
    {
        _next_id++;
        _baseloop.TimerAdd(_next_id, delay, cb);
    }

    // conn对象的SrvClosedCallback回调函数
    void RemoveConnectionInLoop(const PtrConnection &conn)
    {
        int pos = conn->Id();
        auto it = _conns.find(pos);
        if (it != _conns.end())
        {
            _conns.erase(it);
        }
    }
    // conn对象的SrvClosedCallback回调函数
    void RemoveConnection(const PtrConnection &conn)
    {
        return _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }

    // 监听套接字的可读事件触发回调函数
    void NewConnection(int newfd)
    {
        //INF_LOG("NEW CONNECTION");
        _next_id++; // 连接的ID
        PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, newfd));
        /*我们设置的这三个回调，其实更多的是对缓冲区进行操作*/
        conn->SetConnectedCalllback(_connected_callback);
        conn->SetMessageCalllback(_message_callback);
        conn->SetClosedCalllback(_closed_callback);
        conn->SetAnyEventCalllback(_event_callback);
        conn->SetSrvClosedCalllback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));

        /*必须先添加定时销毁任务，然后启动读监控,应为启动了读监控可能立即就有事件触发，这时会触发任意事件刷新定时任务，但是我们还有没添加定时任务，会出错*/
        if (_enable_inactive_release)
        {
            conn->EnableInactiveRelease(_timeout); // 添加定时销毁任务
        }

        conn->Established();                           // 启动初始化
        _conns.insert(std::make_pair(_next_id, conn)); // 将当前connection插入到_conns中
    }
 
public:
    TcpServer(int port) : _next_id(0),
                          _port(port),
                          _enable_inactive_release(false),
                          _acceptor(&_baseloop, _port),
                          _pool(&_baseloop)
    {
        _acceptor.SetAcceptCallBack(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        _acceptor.Listen(); // 将监听套接字挂接到EventLoop上(将要关心的fd设置进epoll中)
    }
     
    void SetThreadCount(int count) { _pool.SetThreadCount(count); };
    /*设置conn的回调函数*/
    void SetConnectedCalllback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCalllback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCalllback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCalllback(const AnyEventCallback &cb) { _event_callback = cb; }

    // 启动超时销毁(是针对从属线程设置的)
    void EnableInactiveRelease(int sec)
    {
        _timeout = sec;
        _enable_inactive_release = true;
    }
    // 添加定时任务，是针对监听套接字的baseloop设置的
    void TimerAdd(const Functor &cb, int delay)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::TimerAddInLoop, this, cb, delay));
    }
    // 启动服务器
    void Start()
    {
        _pool.CreatAndStart();
        _baseloop.Start();
    }
};

void Channel::Remove() { return _loop->RemoveEvent(this); }
void Channel::Update() { return _loop->UpdateEvent(this); }

void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}

void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}
void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}

//捕捉SIGPIPE信号,防止服务器给已经关闭连接的客户端发送消息时收到OS的信号而崩溃。
class NetWork
{
public:
    NetWork()
    {
        signal(SIGPIPE,SIG_IGN);
        INF_LOG("SIGPIPE INIT");
    }
};
static NetWork nw;